// import message from './message.js'
let message = (title)=>{
  return console.log(title);
}

// 模拟延迟时间(毫秒)，模拟网络请求延迟
const MOCK_DELAY = 300

/**
 * Mock HTTP服务
 * 使用本地存储缓存
 * 接口风格与http.js保持一致，便于后期切换到真实后端
 */
const mockHttp = {
  /**
   * 模拟POST请求，将数据存储到本地缓存
   * @param {String} path 请求路径，作为存储的key前缀
   * @param {Object} params 请求参数，将作为数据存储
   * @param {String} contentType 内容类型（保留参数，模拟实际HTTP接口）
   * @param {String} otherUrl 其他URL（保留参数，模拟实际HTTP接口）
   * @returns {Promise} Promise对象
   */
  post(path, params, contentType = 'form', otherUrl) {
    return new Promise((resolve, reject) => {
      try {
        console.log('mockHttp: POST请求', path, params)
        const storageKey = `mock_${path}`
        
        // 根据不同路径处理不同逻辑
        let result
        
        // 处理创建新记录的情况
        if (path.includes('create') || path.includes('add')) {
          // 获取已有数据列表，如果没有则创建新的
          let dataList = uni.getStorageSync(storageKey) || []
          // 确保是数组
          if (!Array.isArray(dataList)) {
            dataList = []
          }
          
          // 为新记录添加ID和创建时间
          const newItem = {
            ...params,
            id: `id_${Date.now()}`,
            createTime: new Date().toISOString()
          }
          
          // 添加新记录
          dataList.push(newItem)
          uni.setStorageSync(storageKey, dataList)
          
          result = {
            code: 200,
            data: newItem,
            message: '创建成功'
          }
        } 
        // 处理更新记录的情况
        else if (path.includes('update')) {
          let dataList = uni.getStorageSync(storageKey) || []
          if (!Array.isArray(dataList)) {
            dataList = []
          }
          
          // 查找并更新记录
          const index = dataList.findIndex(item => item.id === params.id)
          if (index >= 0) {
            const updatedItem = {
              ...dataList[index],
              ...params,
              updateTime: new Date().toISOString()
            }
            dataList[index] = updatedItem
            uni.setStorageSync(storageKey, dataList)
            
            result = {
              code: 200,
              data: updatedItem,
              message: '更新成功'
            }
          } else {
            result = {
              code: 404,
              message: '未找到要更新的记录'
            }
          }
        } 
        // 处理保存整个数据集的情况
        else {
          // 直接保存整个数据
          uni.setStorageSync(storageKey, params)
          
          result = {
            code: 200,
            data: params,
            message: '保存成功'
          }
        }
        
        // 模拟网络延迟
        setTimeout(() => {
          console.log('mockHttp: POST请求成功', result)
          resolve(result)
        }, MOCK_DELAY)
      } catch (err) {
        console.error('mockHttp: POST请求错误', err)
        message.toast.error('请求失败', 'err')
        reject({
          code: 500,
          message: '服务器错误',
          error: err.message
        })
      }
    })
  },
  
  /**
   * 模拟PUT请求，更新本地缓存中的数据
   * @param {String} path 请求路径，作为存储的key前缀
   * @param {Object} params 请求参数，将作为数据存储
   * @param {String} contentType 内容类型（保留参数，模拟实际HTTP接口）
   * @param {String} otherUrl 其他URL（保留参数，模拟实际HTTP接口）
   * @returns {Promise} Promise对象
   */
  put(path, params, contentType = 'form', otherUrl) {
    return new Promise((resolve, reject) => {
      try {
        console.log('mockHttp: PUT请求', path, params)
        const storageKey = `mock_${path}`
        
        // 根据请求路径执行不同操作
        let result
        
        // 处理更新单个对象的情况
        if (params.id) {
          let dataList = uni.getStorageSync(storageKey) || []
          if (!Array.isArray(dataList)) {
            dataList = []
          }
          
          // 查找并更新记录
          const index = dataList.findIndex(item => item.id === params.id)
          if (index >= 0) {
            const updatedItem = {
              ...dataList[index],
              ...params,
              updateTime: new Date().toISOString()
            }
            dataList[index] = updatedItem
            uni.setStorageSync(storageKey, dataList)
            
            result = {
              code: 200,
              data: updatedItem,
              message: '更新成功'
            }
          } else {
            result = {
              code: 404,
              message: '未找到要更新的记录'
            }
          }
        } 
        // 处理批量更新的情况
        else if (Array.isArray(params)) {
          uni.setStorageSync(storageKey, params)
          result = {
            code: 200,
            data: params,
            message: '批量更新成功'
          }
        } 
        // 处理替换整个数据的情况
        else {
          uni.setStorageSync(storageKey, params)
          result = {
            code: 200,
            data: params,
            message: '更新成功'
          }
        }
        
        // 模拟网络延迟
        setTimeout(() => {
          console.log('mockHttp: PUT请求成功', result)
          resolve(result)
        }, MOCK_DELAY)
      } catch (err) {
        console.error('mockHttp: PUT请求错误', err)
        message.toast.error('请求失败', 'err')
        reject({
          code: 500,
          message: '服务器错误',
          error: err.message
        })
      }
    })
  },
  
  /**
   * 模拟GET请求，从本地缓存读取数据
   * @param {String} path 请求路径，作为存储的key前缀
   * @param {Object} params 请求参数，用于过滤数据
   * @param {String} otherUrl 其他URL（保留参数，模拟实际HTTP接口）
   * @returns {Promise} Promise对象
   */
  get(path, params, otherUrl) {
    return new Promise((resolve, reject) => {
      try {
        console.log('mockHttp: GET请求', path, params)
        const storageKey = `mock_${path}`
        
        let result
        let data = uni.getStorageSync(storageKey)
        
        // 如果请求的是列表数据
        if (Array.isArray(data)) {
          // 如果有ID参数，查找单个记录
          if (params && params.id) {
            const item = data.find(item => item.id === params.id)
            if (item) {
              result = {
                code: 200,
                data: item,
                message: '获取成功'
              }
            } else {
              result = {
                code: 404,
                message: '记录不存在',
                data: null
              }
            }
          } 
          // 如果有查询参数，根据参数过滤
          else if (params && Object.keys(params).length > 0) {
            // 简单的过滤逻辑，根据参数筛选
            const filteredData = data.filter(item => {
              return Object.keys(params).every(key => {
                // 支持模糊搜索
                if (typeof item[key] === 'string' && typeof params[key] === 'string') {
                  return item[key].includes(params[key])
                }
                return item[key] === params[key]
              })
            })
            
            result = {
              code: 200,
              data: filteredData,
              total: filteredData.length,
              message: '获取成功'
            }
          } 
          // 没有参数，返回全部数据
          else {
            result = {
              code: 200,
              data: data,
              total: data.length,
              message: '获取成功'
            }
          }
        } 
        // 如果请求的是单个对象
        else if (data) {
          result = {
            code: 200,
            data: data,
            message: '获取成功'
          }
        } 
        // 如果数据不存在
        else {
          result = {
            code: 404,
            message: '数据不存在',
            data: null
          }
        }
        
        // 模拟网络延迟
        setTimeout(() => {
          console.log('mockHttp: GET请求成功', result)
          resolve(result)
        }, MOCK_DELAY)
      } catch (err) {
        console.error('mockHttp: GET请求错误', err)
        message.toast.error('请求失败', 'err')
        reject({
          code: 500,
          message: '服务器错误',
          error: err.message
        })
      }
    })
  },
  
  /**
   * 模拟DELETE请求，从本地缓存删除数据
   * @param {String} path 请求路径，作为存储的key前缀
   * @param {Object} params 请求参数，用于确定要删除的数据
   * @param {String} otherUrl 其他URL（保留参数，模拟实际HTTP接口）
   * @returns {Promise} Promise对象
   */
  delete(path, params, otherUrl) {
    return new Promise((resolve, reject) => {
      try {
        console.log('mockHttp: DELETE请求', path, params)
        const storageKey = `mock_${path}`
        
        let result
        
        // 如果提供了ID参数，删除单个记录
        if (params && params.id) {
          let dataList = uni.getStorageSync(storageKey) || []
          if (!Array.isArray(dataList)) {
            dataList = []
          }
          
          const initialLength = dataList.length
          dataList = dataList.filter(item => item.id !== params.id)
          
          if (dataList.length < initialLength) {
            uni.setStorageSync(storageKey, dataList)
            result = {
              code: 200,
              message: '删除成功'
            }
          } else {
            result = {
              code: 404,
              message: '未找到要删除的记录'
            }
          }
        } 
        // 如果提供了批量删除的ID数组
        else if (params && Array.isArray(params.ids)) {
          let dataList = uni.getStorageSync(storageKey) || []
          if (!Array.isArray(dataList)) {
            dataList = []
          }
          
          const initialLength = dataList.length
          dataList = dataList.filter(item => !params.ids.includes(item.id))
          
          if (dataList.length < initialLength) {
            uni.setStorageSync(storageKey, dataList)
            result = {
              code: 200,
              message: '批量删除成功',
              deleted: initialLength - dataList.length
            }
          } else {
            result = {
              code: 404,
              message: '未找到要删除的记录'
            }
          }
        }
        // 没有明确参数，清空所有数据
        else if (path.includes('clear') || path.includes('removeAll')) {
          uni.removeStorageSync(storageKey)
          result = {
            code: 200,
            message: '清空数据成功'
          }
        }
        // 其他情况返回错误
        else {
          result = {
            code: 400,
            message: '删除请求参数错误'
          }
        }
        
        // 模拟网络延迟
        setTimeout(() => {
          console.log('mockHttp: DELETE请求成功', result)
          resolve(result)
        }, MOCK_DELAY)
      } catch (err) {
        console.error('mockHttp: DELETE请求错误', err)
        message.toast.error('请求失败', 'err')
        reject({
          code: 500,
          message: '服务器错误',
          error: err.message
        })
      }
    })
  },
  
  /**
   * 模拟文件上传，将文件信息存储到本地缓存
   * @param {String} path 请求路径
   * @param {Array} fileArray 文件路径数组
   * @param {String} otherUrl 其他URL（保留参数）
   * @returns {Promise} Promise对象
   */
  upload(path, fileArray, otherUrl) {
    return new Promise((resolve, reject) => {
      try {
        console.log('mockHttp: 文件上传', path, fileArray)
        
        if (!Array.isArray(fileArray)) {
          throw new Error('文件参数必须是数组')
        }
        
        // 模拟文件上传结果
        const uploadResults = fileArray.map((filePath, index) => {
          // 模拟文件ID和URL
          return {
            id: `file_${Date.now()}_${index}`,
            url: filePath,
            name: filePath.split('/').pop(),
            size: Math.floor(Math.random() * 1000000),
            type: filePath.split('.').pop(),
            uploadTime: new Date().toISOString()
          }
        })
        
        // 存储上传的文件信息
        const storageKey = `mock_${path}`
        let existingFiles = uni.getStorageSync(storageKey) || []
        if (!Array.isArray(existingFiles)) {
          existingFiles = []
        }
        
        const updatedFiles = [...existingFiles, ...uploadResults]
        uni.setStorageSync(storageKey, updatedFiles)
        
        const result = {
          code: 200,
          data: uploadResults,
          message: '上传成功'
        }
        
        // 模拟网络延迟
        setTimeout(() => {
          console.log('mockHttp: 文件上传成功', result)
          resolve(result)
        }, MOCK_DELAY * 2) // 文件上传通常需要更长时间
      } catch (err) {
        console.error('mockHttp: 文件上传错误', err)
        message.toast.error('上传失败', 'err')
        reject({
          code: 500,
          message: '服务器错误',
          error: err.message
        })
      }
    })
  },
  
  /**
   * 清除指定路径的模拟数据
   * @param {String} path 要清除的数据路径
   * @returns {Promise} Promise对象
   */
  clearMockData(path) {
    return new Promise((resolve) => {
      const storageKey = `mock_${path}`
      uni.removeStorageSync(storageKey)
      console.log('mockHttp: 清除数据', storageKey)
      resolve({
        code: 200,
        message: '数据已清除'
      })
    })
  },
  
  /**
   * 获取所有模拟数据的键名
   * @returns {Array} 所有模拟数据的键名数组
   */
  getAllMockKeys() {
    try {
      const keys = []
      const res = uni.getStorageInfoSync()
      if (res.keys) {
        res.keys.forEach(key => {
          if (key.startsWith('mock_')) {
            keys.push(key)
          }
        })
      }
      return keys
    } catch (e) {
      console.error('获取存储信息失败', e)
      return []
    }
  },
  
  /**
   * 初始化模拟数据，可用于预设一些基础数据
   * @param {Object} initialData 初始数据对象，键为路径，值为数据
   */
  initMockData(initialData) {
    if (!initialData || typeof initialData !== 'object') return
    
    Object.keys(initialData).forEach(path => {
      const storageKey = `mock_${path}`
      // 只有当数据不存在时才初始化
      if (!uni.getStorageSync(storageKey)) {
        uni.setStorageSync(storageKey, initialData[path])
        console.log('mockHttp: 初始化数据', storageKey)
      }
    })
  }
}

export default mockHttp 